home *** CD-ROM | disk | FTP | other *** search
/ CU Amiga Super CD-ROM 15 / CU Amiga Magazine's Super CD-ROM 15 (1997)(EMAP Images)(GB)[!][issue 1997-10].iso / CUCD / Utilities / Post / Source / Utility.c < prev   
Encoding:
C/C++ Source or Header  |  1997-05-03  |  12.2 KB  |  523 lines
  1. #include "PostPre.h"
  2. #include "Global.h"
  3. #include <intuition/intuitionbase.h>
  4. #include <utility/hooks.h>
  5.  
  6. #define    MENU_PROJECT    0
  7. #define    ITEM_NEW            0
  8. #define    ITEM_CLEAR        1
  9. #define    ITEM_OFILE        3
  10. #define    ITEM_RFILE        4
  11. #define    ITEM_LFONT        5
  12. #define    ITEM_SAVEIFF    7
  13. #define    ITEM_PRINT        9
  14. #define    ITEM_ABOUT        11
  15. #define    ITEM_QUIT        13
  16.  
  17. #define    MENU_CONTROL    1
  18. #define    ITEM_PAUSE        0
  19. #define    ITEM_NEXT        2
  20. #define    ITEM_PREV        3
  21. #define    ITEM_GOTO        4
  22. #define    ITEM_INTERRUPT    6
  23. #define    ITEM_KILL        7
  24. #define    ITEM_INTER        9
  25.  
  26. #define    MENU_PREFS        2
  27. #define    ITEM_PUB            0
  28. #define    ITEM_CUSTOM        1
  29. #define    ITEM_OPTIONS    2
  30.  
  31. /* sigintmain() is called when the main programm recieves a CTRL-C */
  32.  
  33. void __saveds sigintmain()
  34. {
  35.     Signal((struct Task *) rendertask, 1L << SIGBREAKB_CTRL_C);
  36. }
  37.  
  38. /* sigint() is called when the rendertask recieves a CTRL-C */
  39.  
  40. void __saveds sigint()
  41. {
  42.     if(arec && !argwindow && running)
  43.     {
  44.         PSsignalint(arec, 1);
  45.         ioerror = errinterrupt;
  46.     }
  47. }
  48.  
  49. /* sigfpe() is called when a floating point error occurs in the rendertask */
  50.  
  51. void __saveds sigfpe()
  52. {
  53.     if(arec) PSsignalfpe(arec);
  54. }
  55.  
  56. /* Send a mesage to the rendering subtask */
  57.  
  58. void sendmenu(int action, int nop, int from, int to, char *file, char *directory)
  59. {
  60.     struct PSmessage *psmsg;
  61.  
  62.     if(psmsg = AllocMem(sizeof(struct PSmessage), MEMF_PUBLIC))
  63.     {
  64.         psmsg->action = action;
  65.         if(file) strcpy(psmsg->file, file);
  66.         else psmsg->file[0] = 0;
  67.         if(directory) strcpy(psmsg->directory, directory);
  68.         else psmsg->directory[0] = 0;
  69.  
  70. /* Save rmsg. In case of action == PSACTAREXX the ARexxMsg is not replied    *
  71.  * immediately. It is replied when the subtask has interpreted the string.    *
  72.  * This way it is possible to synchronise the interpreter with an Arexx     *
  73.  * script that in turn can react to an error the interpreter generates.        */
  74.  
  75.         if(action == PSACTAREXX) psmsg->rmsg = rmsg;
  76.         else psmsg->rmsg = NULL;
  77.         psmsg->numofpages = nop;
  78.         psmsg->from = from;
  79.         psmsg->to    = to;
  80.  
  81.         psmsg->ExecMessage.mn_ReplyPort = mainport;
  82.         psmsg->ExecMessage.mn_Node.ln_Type = NT_MESSAGE;
  83.         psmsg->ExecMessage.mn_Length = sizeof(struct PSmessage);
  84.  
  85.         PutMsg(renderport, (struct Message *) psmsg);
  86.     }
  87. }
  88.  
  89.  
  90. /* Display a message */
  91.  
  92. void okmsg(char *string)
  93. {
  94.     struct    Screen *scr;
  95.     struct EasyStruct myES =
  96.     {
  97.         sizeof(struct EasyStruct),
  98.         0,
  99.         "Post Information",
  100.         "",
  101.         "Ok",
  102.     };
  103.  
  104.     if (IntuitionBase)
  105.     {
  106.         if (Options.Screen.custscreen) scr = custscreen;
  107.         else scr = pubscrcontext.pubscreen;
  108.         if(scr == 0) scr = IntuitionBase->FirstScreen;
  109.         myES.es_TextFormat = string;
  110.         EasyRequest((OutputWnd == 0) ? scr->FirstWindow : OutputWnd, &myES, NULL);
  111.     }
  112.     else puts(string);
  113. }
  114.  
  115. void    GetNeededPens(struct PubScrContext *pscontext)
  116. {
  117.     LONG    PenNum;
  118.     ULONG r[9] = {0xffffffff, 0x00000000, 0xffffffff, 0x00000000,
  119.                       0xffffffff, 0x00000000, 0xffffffff, 0x00000000, 0x00000000},
  120.             g[9] = {0xffffffff, 0xffffffff, 0x00000000, 0x00000000,
  121.                       0xffffffff, 0xffffffff, 0x00000000, 0x00000000, 0x00000000},
  122.             b[9] = {0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff,
  123.                       0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000},
  124.             test[27], temp;
  125.     UBYTE ro[9] = {0xf, 0x0, 0xf, 0x0, 0xf, 0x0, 0xf, 0x0, 0x0},
  126.             go[9] = {0xf, 0xf, 0x0, 0x0, 0xf, 0xf, 0x0, 0x0, 0x0},
  127.             bo[9] = {0xf, 0xf, 0xf, 0xf, 0x0, 0x0, 0x0, 0x0, 0x0};
  128.     int    i, j, start, end;
  129.     BOOL    ok = TRUE;
  130.     struct ColorMap *pubsc_cm;
  131.  
  132.     pscontext->depth = Options.PostOpts.depth;
  133.     if(Options.PostOpts.depth == 1)
  134.     {
  135.         pscontext->got_pens    = FALSE;
  136.         pscontext->pens_ok    = TRUE;
  137.         return;
  138.     }
  139.     else if((pscontext->pubscreen->RastPort.BitMap)->Depth < Options.PostOpts.depth + 1)
  140.     {
  141.         pscontext->got_pens    = FALSE;
  142.         pscontext->pens_ok    = FALSE;
  143.         return;
  144.     }
  145.     pubsc_cm = (&(pscontext->pubscreen)->ViewPort)->ColorMap;
  146.     if(Options.PostOpts.depth == 3)
  147.     {
  148.         start = 8;
  149.         end = 16;
  150.     }
  151.     else
  152.     {
  153.         start = 16;
  154.         end = 25;
  155.     }
  156.     if(os_3 == FALSE)
  157.     {
  158.         for(i=start; i < end; i++)
  159.         {
  160.             temp = GetRGB4(pubsc_cm, i);
  161. /*            printf("temp = %x, %x, %x\n", temp, ((temp >> 8) & 0xf), ro[i-8]);*/
  162.             if( ((temp >> 8) & 0xf) != ro[i-8])
  163.             {
  164.                 ok = FALSE;
  165.                 break;
  166.             }
  167.             if( ((temp >> 4) & 0xf) != go[i-8])
  168.             {
  169.                 ok = FALSE;
  170.                 break;
  171.             }
  172.             if( ((temp >> 0) & 0xf) != bo[i-8])
  173.             {
  174.                 ok = FALSE;
  175.                 break;
  176.             }
  177.         }
  178.         pscontext->got_pens    = FALSE;
  179.         pscontext->pens_ok    = ok;
  180.         return;
  181.     }
  182.     GetRGB32(pubsc_cm, start, end-start, test);
  183.     for(i=0; i < end-start; i++)
  184.     {
  185. /*        printf("test[%2d] = %x, test[%2d] = %x, test[%2d] = %x, %x\n",
  186.                     i, test[i], i+1, test[i+1], i+2, test[i+2], r[i]);*/
  187.         if((test[3*i] != r[i]) || (test[3*i+1] != g[i]) ||
  188.             (test[3*i+2] != b[i]))
  189.         {
  190.             ok = FALSE;
  191.             break;
  192.         }
  193.     }
  194. /*    printf("ok = %d\n", ok);*/
  195.     if(ok)
  196.     {
  197.         pscontext->got_pens    = FALSE;
  198.         pscontext->pens_ok    = ok;
  199.         return;
  200.     }
  201.     for(i=0; i < end-start; i++)
  202.     {
  203.         PenNum = ObtainPen(pubsc_cm, i+start, r[i], g[i], b[i], 0);
  204. /*        printf("i = %d\n", i);*/
  205.         if(PenNum == -1)
  206.         {
  207.             for(j=0; j < i; j++)
  208.             {
  209.                 ReleasePen(pubsc_cm, j+start);
  210.             }
  211.             pscontext->got_pens    = FALSE;
  212.             pscontext->pens_ok    = FALSE;
  213.             return;
  214.         }
  215.     }
  216.     pscontext->got_pens    = TRUE;
  217.     pscontext->pens_ok    = TRUE;
  218. }
  219.  
  220. void ReleaseNeededPens(struct PubScrContext *pscontext)
  221. {
  222.     int    i, count, start;
  223.     struct ColorMap *pubsc_cm;
  224.  
  225.     if(pscontext->got_pens == FALSE) return;
  226.     if(pscontext->depth == 3)
  227.     {
  228.         start = 8;
  229.         count = 8;
  230.     }
  231.     else
  232.     {
  233.         start = 16;
  234.         count = 9;
  235.     }
  236.     pubsc_cm = (&(pscontext->pubscreen)->ViewPort)->ColorMap;
  237.     for(i=0; i < count; i++)
  238.     {
  239.         ReleasePen(pubsc_cm, i+start);
  240.     }
  241.     pscontext->got_pens = FALSE;
  242. }
  243.  
  244. static    int    numberofpages = 0;
  245.  
  246. int splitpage(char *file)
  247. {
  248.     FILE    *tempfile, *postfile;
  249.     char    line[256], buffer[30], *postfilebuf;
  250.     BOOL    trailer = FALSE, page = FALSE;
  251.  
  252.     page_number = 1;
  253.     delete_tempfiles();
  254.     numberofpages = 0;
  255.     postfile = fopen(file, "r");
  256.  
  257.     if (postfile == NULL)
  258.     {
  259.         okmsg("can't open postscript file");
  260.         return(FALSE);
  261.     }
  262.     if(postfilebuf = malloc(Options.bufsize)) setvbuf(postfile, postfilebuf, _IOLBF, Options.bufsize);
  263.     sprintf(buffer, "%sPrologue%d.ps",  Options.temppath, post_count);
  264.     tempfile = fopen(buffer, "w");
  265.     if (tempfile == NULL)
  266.     {
  267.         okmsg("can't open temporary file");
  268.         fclose(postfile);
  269.         free(postfilebuf);
  270.         return(FALSE);
  271.     }
  272.  
  273.     fgets(line, 256, postfile);
  274.     if(strncmp(line, "%!PS-Adobe-", strlen("%!PS-Adobe-")))
  275.     {
  276.         fclose(tempfile);
  277.         fclose(postfile);
  278.         free(postfilebuf);
  279.         return(FALSE);
  280.     }
  281.     if(fputs(line, tempfile))
  282.     {
  283.         fclose(tempfile);
  284.         fclose(postfile);
  285.         free(postfilebuf);
  286.         return(FALSE);
  287.     }
  288.     while (fgets(line, 256, postfile))
  289.     {
  290.         if(!strncmp(line, "%%Page:", strlen("%%Page:")))
  291.         {
  292.             page = TRUE;
  293.             numberofpages++;
  294.             fclose(tempfile);
  295.             sprintf(buffer, "%sPage%04d_%d.ps",  Options.temppath, numberofpages, post_count);
  296.             tempfile = fopen(buffer, "w");
  297.             if(tempfile == NULL)
  298.             {
  299.                 okmsg("can't open temporary file");
  300.                 fclose(postfile);
  301.                 free(postfilebuf);
  302.                 return(FALSE);
  303.             }
  304.         }
  305.         if(!strncmp(line, "%%Trailer", strlen("%%Trailer")))
  306.         {
  307.             trailer=TRUE;
  308.             fclose(tempfile);
  309.             sprintf(buffer, "%sTrailer%d.ps",  Options.temppath, post_count);
  310.             tempfile = fopen(buffer, "w");
  311.             if(tempfile == NULL)
  312.             {
  313.                 okmsg("can't open temporary file");
  314.                 fclose(postfile);
  315.                 free(postfilebuf);
  316.                 return(FALSE);
  317.             }
  318.         }
  319.         if(fputs(line, tempfile))
  320.         {
  321.             fclose(tempfile);
  322.             fclose(postfile);
  323.             free(postfilebuf);
  324.             return(FALSE);
  325.         }
  326.     }
  327.     fclose(tempfile);
  328.     fclose(postfile);
  329.     free(postfilebuf);
  330.     if(trailer && page) return(numberofpages);
  331.     else return(FALSE);
  332. }
  333.  
  334. void    delete_tempfiles(void)
  335. {
  336.     int    i;
  337.     char    buf[MAXFILENAME];
  338.  
  339.     sprintf(buf, "%sPrologue%d.ps", Options.temppath, post_count);
  340.     remove(buf);
  341.     sprintf(buf, "%sTrailer%d.ps",  Options.temppath, post_count);
  342.     remove(buf);
  343.     if(numberofpages)
  344.     {
  345.         for(i=0; i < numberofpages; i++)
  346.         {
  347.             sprintf(buf, "%sPage%04d_%d.ps",  Options.temppath, i+1, post_count);
  348.             remove(buf);
  349.         }
  350.     }
  351. }
  352.  
  353. /* because modeID is defined as APTR __regargs puts it in a1 :-)            */
  354.  
  355. ULONG __saveds __regargs ModeIDHook (struct Hook *hook, APTR modeID)
  356. {
  357.     struct DimensionInfo di;
  358.  
  359.     if(GetDisplayInfoData(FindDisplayInfo((ULONG) modeID), (APTR) &di, sizeof(struct DimensionInfo),
  360.         DTAG_DIMS, (ULONG) modeID))
  361.     {
  362.         if(di.MaxDepth >= Options.PostOpts.depth+1) return(TRUE);
  363.         else return(FALSE);
  364.     }
  365.     else
  366.     {
  367.         return(FALSE);
  368.     }
  369. }
  370.  
  371. int Menu_ScreenMode( void )
  372. {
  373.     struct ScreenModeRequester *smr;
  374.     struct Hook    modehook;
  375.  
  376.     modehook.h_Entry = (APTR) ModeIDHook;
  377.     smr = (struct ScreenModeRequester *) AllocAslRequestTags(
  378.                                     ASL_ScreenModeRequest,
  379.                                     ASLSM_DoWidth,                        TRUE,
  380.                                     ASLSM_DoHeight,                    TRUE,
  381.                                     ASLSM_DoDepth,                        FALSE,
  382.                                     ASLSM_DoAutoScroll,                TRUE,
  383.                                     ASLSM_DoOverscanType,            TRUE,
  384.                                     ASLSM_Window,                        (ULONG) OutputWnd,
  385.                                     ASLSM_InitialDisplayWidth,        Options.Screen.ScrWidth,
  386.                                     ASLSM_InitialDisplayHeight,    Options.Screen.ScrHeight,
  387.                                     ASLSM_InitialDisplayID,            Options.Screen.ScrDisplayID,
  388.                                     ASLSM_InitialAutoScroll,        Options.Screen.ScrAutoScroll,
  389.                                     ASLSM_InitialOverscanType,        Options.Screen.ScrOverscanType,
  390.                                     ASLSM_FilterFunc,                    (ULONG) &modehook,
  391. /*                                    ASLSM_PropertyFlags,                DIPF_IS_WB | DIPF_IS_LACE,
  392.                                     ASLSM_PropertyMask,                DIPF_IS_WB | DIPF_IS_LACE,*/
  393.                                     TAG_DONE);
  394.     if(smr == NULL)
  395.     {
  396.         okmsg("Can't open Screenmoderequester!");
  397.         return(0);
  398.     }
  399.  
  400.     if(AslRequest(smr, NULL))
  401.     {
  402.         Options.Screen.ScrWidth = smr->sm_DisplayWidth;
  403.         Options.Screen.ScrHeight = smr->sm_DisplayHeight;
  404.         Options.Screen.ScrDisplayID = smr->sm_DisplayID;
  405.         Options.Screen.ScrOverscanType = smr->sm_OverscanType;
  406.         Options.Screen.ScrAutoScroll = smr->sm_AutoScroll;
  407.         FreeAslRequest(smr);
  408.     }
  409.     else
  410.     {
  411.         FreeAslRequest(smr);
  412.         return(1);
  413.     }
  414.     return(0);
  415. }
  416.  
  417. void    setmenu(void)
  418. {
  419.     if (!Options.Screen.custscreen)
  420.     {
  421.         menu2->FirstItem->Flags |=  CHECKED;
  422.         menu2->FirstItem->NextItem->Flags &=  ~CHECKED;
  423.     }
  424.     else
  425.     {
  426.         menu2->FirstItem->Flags &= ~CHECKED;
  427.         menu2->FirstItem->NextItem->Flags |=  CHECKED;
  428.     }
  429.     if (pause) menu1->FirstItem->Flags |=  CHECKED;
  430.     else menu1->FirstItem->Flags &= ~CHECKED;
  431.  
  432.     if(running && paused)
  433.     {
  434.         OnMenu(OutputWnd, MENU_CONTROL | SHIFTITEM(ITEM_NEXT));
  435.     }
  436.     else
  437.     {
  438.         OffMenu(OutputWnd, MENU_CONTROL | SHIFTITEM(ITEM_NEXT));
  439.     }
  440.     if(running && paused && number_of_pages)
  441.     {
  442.         OnMenu(OutputWnd, MENU_CONTROL | SHIFTITEM(ITEM_GOTO));
  443.         OnMenu(OutputWnd, MENU_CONTROL | SHIFTITEM(ITEM_PREV));
  444.     }
  445.     else
  446.     {
  447.         OffMenu(OutputWnd, MENU_CONTROL | SHIFTITEM(ITEM_GOTO));
  448.         OffMenu(OutputWnd, MENU_CONTROL | SHIFTITEM(ITEM_PREV));
  449.     }
  450.     if(running && !paused && !interactive)
  451.     {
  452.         OnMenu(OutputWnd, MENU_CONTROL | SHIFTITEM(ITEM_INTERRUPT));
  453.         OnMenu(OutputWnd, MENU_CONTROL | SHIFTITEM(ITEM_KILL));
  454.     }
  455.     else
  456.     {
  457.         OffMenu(OutputWnd, MENU_CONTROL | SHIFTITEM(ITEM_INTERRUPT));
  458.         OffMenu(OutputWnd, MENU_CONTROL | SHIFTITEM(ITEM_KILL));
  459.     }
  460.     if(interactive)
  461.     {
  462.         OffMenu(OutputWnd, MENU_PROJECT | SHIFTITEM(NOITEM));
  463.         OffMenu(OutputWnd, MENU_PREFS |  SHIFTITEM(NOITEM));
  464.         OffMenu(OutputWnd, MENU_CONTROL | SHIFTITEM(ITEM_INTERRUPT));
  465.         OffMenu(OutputWnd, MENU_CONTROL | SHIFTITEM(ITEM_KILL));
  466.         OffMenu(OutputWnd, MENU_CONTROL | SHIFTITEM(ITEM_INTER));
  467.     }
  468.     else
  469.     {
  470.         OnMenu(OutputWnd, MENU_PROJECT | SHIFTITEM(NOITEM));
  471.         OnMenu(OutputWnd, MENU_PREFS |  SHIFTITEM(NOITEM));
  472.         OnMenu(OutputWnd, MENU_CONTROL | SHIFTITEM(ITEM_INTER));
  473.     }
  474.     if(startup)
  475.     {
  476.         OffMenu(OutputWnd, MENU_PROJECT | SHIFTITEM(NOITEM));
  477.         OffMenu(OutputWnd, MENU_CONTROL | SHIFTITEM(ITEM_PAUSE));
  478.         OffMenu(OutputWnd, MENU_CONTROL | SHIFTITEM(ITEM_INTER));
  479.         OffMenu(OutputWnd, MENU_PREFS | SHIFTITEM(NOITEM));
  480.     }
  481.     else
  482.     {
  483.         OnMenu(OutputWnd, MENU_PROJECT | SHIFTITEM(NOITEM));
  484.         OnMenu(OutputWnd, MENU_CONTROL | SHIFTITEM(ITEM_PAUSE));
  485.         OnMenu(OutputWnd, MENU_CONTROL | SHIFTITEM(ITEM_INTER));
  486.         OnMenu(OutputWnd, MENU_PREFS | SHIFTITEM(NOITEM));
  487.     }
  488. }
  489.  
  490. BPTR    oldlock, newlock;
  491.  
  492. void    changedir(char *directory)
  493. {
  494.     newlock = Lock(directory, ACCESS_READ);
  495.     if(newlock)
  496.     {
  497.         oldlock = CurrentDir(newlock);
  498.         if(oldlock) UnLock(oldlock);
  499.     }
  500. }
  501.  
  502. void    getpath(char *directory, char *fullfilename)
  503. {
  504.     strcpy(directory, fullfilename);
  505.     directory[(ULONG)PathPart(fullfilename) - (ULONG)fullfilename] = '\0';
  506. }
  507.  
  508. void    getfullfilename(char *fullname, char *dir, char *file)
  509. {
  510.     strcpy(fullname, dir);
  511.     AddPart(fullname, file, 255);
  512. }
  513.  
  514. void    sendfile(int mode)
  515. {
  516.     saveterminate();
  517.     if(mode == PSACTFILE) number_of_pages = splitpage(Options.lastfile);
  518.     getpath(Options.lastdir, Options.lastfile);
  519.     changedir(Options.lastdir);
  520.     sendmenu(mode, (mode == PSACTFILE) ? number_of_pages : 0, 1, 0,
  521.                 Options.lastfile, Options.lastdir);
  522. }
  523.